/*
 * Copyright 2019-2020 北京掌上先机网络科技有限公司
 */

package com.zxsj.fdk.study.common.utils;


import javax.validation.constraints.NotNull;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author zhengbaole
 */
public class StringUtils {

    /**
     * 分隔符
     */
    static String DEFAULT_SEPARATOR = ",";

    /**
     * 小写下划线 转 小写驼峰
     */
    public static String camelCase2Underline(String underLineString) {
        StringBuilder result = new StringBuilder();
        char[] chars = underLineString.toCharArray();
        for (char c : chars) {
            if (c >= 'A' && c <= 'Z') {
                result.append("_").append((char) (c + 32));
            } else {
                result.append(c);
            }
        }
        return result.toString();
    }

    /**
     * 小写驼峰 转 小写下划线
     */
    public static String underLine2CamelCase(String underLineString) {
        StringBuilder result = new StringBuilder();
        StringBuilder buffer = new StringBuilder();
        char[] chars = underLineString.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            if (c == '_') {
                buffer.append((char) (chars[(i + 1)] - 32));
                i++;
                continue;
            } else {
                buffer.append(c);
            }
            result.append(buffer);
            buffer = new StringBuilder();
        }
        return result.toString();
    }

    public static boolean isEmpty(String string) {
        return org.springframework.util.StringUtils.isEmpty(string);
    }

    /**
     * 生成唯一键
     *
     * @return 唯一键如：4e00c7ed-35d5-4b3f-82ab-d121d2891184
     */
    public static String uuid() {
        return UUID.randomUUID().toString();
    }

    /**
     * 生成唯一键
     *
     * @return 唯一键如：4e00c7ed35d54b3f82abd121d2891184
     */
    public static String tinyUUID() {
        return uuid().replaceAll("-", "");
    }

    /**
     * 字符串转 List
     *
     * @param value 逗号连接的字符串
     */
    public static List<String> stringToList(String value) {
        if (isEmpty(value)) {
            return Collections.emptyList();
        }
        return Arrays.stream(value.trim().split(DEFAULT_SEPARATOR)).collect(Collectors.toList());
    }

    /**
     * 字符串转 List
     *
     * @param value 整型值列表
     */
    public static String listToString(List<Integer> value) {
        if (null == value || value.isEmpty()) {
            return "";
        }
        return value.stream().map(String::valueOf).collect(Collectors.joining(DEFAULT_SEPARATOR));
    }

    /**
     * 字符串转 List
     *
     * @param value 字符创列表
     */
    public static String listStringToString(List<String> value) {
        if (null == value || value.isEmpty()) {
            return "";
        }
        return String.join(DEFAULT_SEPARATOR, value);
    }

    /**
     * 从路径中得到文件名
     *
     * @param path 路径
     * @return 文件名
     */
    public static String getFileNameFromPath(String path) {
        return path.substring(path.lastIndexOf('/') + 1);
    }

    /**
     * '\'替换为 '/'的方法
     *
     * @param srcStr 原字符串
     * @return 分隔符转换后的字符串
     */
    public static String shiftSeparator(String srcStr) {
        return srcStr.replaceAll("\\\\", "/");
    }

    /**
     * 字符串通过分割符转成整型数组
     * 默认分隔符 “,"
     *
     * @param origin 源字符串
     */
    @NotNull
    public static List<Integer> stringToIntegerList(String origin) {
        return stringToIntegerList(origin, DEFAULT_SEPARATOR);
    }

    /**
     * 字符串通过分割符转成整型数组
     *
     * @param origin    源字符串
     * @param delimiter 分隔符
     */
    @NotNull
    public static List<Integer> stringToIntegerList(String origin, String delimiter) {
        if (isEmpty(origin)) {
            return Collections.emptyList();
        }
        String[] originArr = origin.split(delimiter);
        return Arrays.stream(originArr).map(Integer::valueOf).collect(Collectors.toList());
    }

    /**
     * 字符串通过分割符转成字符串数组
     * 默认分隔符 “,"
     *
     * @param origin 源字符串
     */
    @NotNull
    public static List<String> stringToStringList(String origin) {
        return Stream.of(Objects.requireNonNull(origin).split(DEFAULT_SEPARATOR))
                .collect(Collectors.toList());
    }

    /**
     * 获取中文字符的个数
     *
     * @param content 文本
     */
    public static int chineseCharactersNum(String content) {
        return (content.getBytes((StandardCharsets.UTF_8)).length - content.length()) / 2;
    }

    /**
     * 判断字符串是否为空三目运算
     *
     * @param value        字符值
     * @param firstResult  第一个值
     * @param secondResult 第二个值
     * @param <T>          类型
     */
    static <T> T ternaryOperation(String value, T firstResult, T secondResult) {
        return value.trim().isEmpty() ? firstResult : secondResult;
    }

    /**
     * 字符串是否为数值类型
     *
     * @param str 字符
     */
    static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]+$");
        return pattern.matcher(str).matches();
    }

    /**
     * 字符串是否有非空内容
     *
     * @param str 字符
     */
    public static boolean isSpace(String str) {
        if (str == null) {
            return true;
        }
        String trimStr = str.trim();
        return isEmpty(trimStr);
    }

    /**
     * 判断两个可能为空的字符串是否相等
     *
     * @param a
     * @param b
     * @author liuyuqing
     * @lastEditor liuyuqing
     * @createTime 2021/3/11 10:42
     * @editTime 2021/3/11 10:42
     **/
    public static boolean isEqual(String a, String b) {
        if (a == null && b == null) {
            return true;
        }
        if (a != null && b != null) {
            return a.equals(b);
        }
        return false;
    }

    /**
     * 截取字符串
     *
     * @param str 待截取的字符串
     * @param end 截取的位数
     * @author liuyuqing
     * @lastEditor liuyuqing
     * @createTime 2021/4/20 13:32
     * @editTime 2021/4/20 13:32
     **/
    public static String subString(String str, int end) {
        if (str == null) {
            return "";
        }
        if (str.length() <= end) {
            return str;
        }
        return str.substring(0, end);
    }
}
